home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d12 / cc02.arc / EXPAND.C < prev    next >
Text File  |  1986-03-14  |  5KB  |  216 lines
  1. /**   EXPAND.C -  expands tab characters into 8 blank spaces and optionally
  2.                   deletes header record.  Used for DIFFS and PROMOTE.
  3.  
  4.                   written  03-14-85    by Rick Leeper
  5.                   updated  04-15-85    by Rick Leeper
  6. **/
  7.  
  8. #include "stdio.h"
  9. #include "ctype.h"
  10. #include "def.h"
  11. #include "ascii.h"
  12.  
  13. #define  MAXTMP         96
  14. #define  STRIP_HEADER   0x01
  15.  
  16. struct XREG
  17.         {
  18.         short ax,bx,cx,dx,si,di;
  19.         };
  20. struct HREG
  21.         {
  22.         char al,ah,bl,bh,cl,ch,dl,dh;
  23.         };
  24. union REGS
  25.         {
  26.         struct XREG x;
  27.         struct HREG h;
  28.         };
  29.  
  30. main(argc,argv)
  31. int   argc;
  32. char  *argv[];
  33. {
  34.       char  *spt, *dpt;
  35.       char  tmpfile[MAXTMP+1];
  36.       int   ret;
  37.  
  38.       if (argc > 3) {
  39.          printf("USAGE:\n     EXPAND [d:{path\}]filename.ext -flags\n");
  40.          exit(-1);
  41.       }
  42.  
  43.       spt = argv[1];
  44.       dpt = &tmpfile[0];
  45.  
  46.       clrbuf(dpt, MAXTMP+1);
  47.  
  48.       maketmp(spt, dpt);
  49.  
  50.       if ((ret = copyfile(spt, dpt)) != NULL) {
  51.          printf("\nERROR: copy unsuccessful\n");
  52.          exit(ret);
  53.       }
  54.  
  55.       rename(dpt, spt);
  56. }
  57.  
  58. clrbuf(string, length)
  59. int   length;
  60. char  *string;
  61. {
  62.       int   i;
  63.  
  64.       for (i = 0; i < length; i++, *string++ = '\0')
  65.          ;
  66. }
  67.  
  68. maketmp(oldfile, tmpfile)
  69. char  *oldfile, *tmpfile;
  70. {
  71.       static char tmp[] = ".TMP";
  72.       char  *tpt = &tmp[0];
  73.       int   c;
  74.  
  75.       while ((c = *oldfile) != '.' && c != '\0')
  76.          *tmpfile++ = *oldfile++;
  77.  
  78.       while ((c = *tpt) != '\0')
  79.          *tmpfile++ = *tpt++;
  80.  
  81.       return(0);
  82. }
  83.  
  84. copyfile(oldfile, newfile)
  85. char  *oldfile, *newfile;
  86. {
  87.       extern   int   argc;
  88.       extern   char  *argv[];
  89.  
  90.       static   char  header[] = "HEADER";
  91.  
  92.       int      c = 32, space, lncnt = 0, colcnt, d, flags;
  93.       char     buf[MAXTMP+1], *bufptr = &buf[0], *hdrptr = &header[0];
  94.  
  95.       FILE     *org, *tmp, *new;
  96.  
  97.       if ((org = fopen(oldfile, "r")) == NULL)
  98.          return (EOF);
  99.       if ((tmp = fopen(newfile, "w")) == NULL)
  100.          return (EOF);
  101.  
  102.       if (argc == 3 && *argv[2] == '-') {
  103.          flags = chk_flags(argv[2]);
  104.  
  105.          if ((flags & STRIP_HEADER) == STRIP_HEADER) {
  106.             clrbuf(&buf[0], MAXTMP+1);
  107.             colcnt = 0;
  108.             while ((c = fgetc(org)) != CR && c != LF) {
  109.                if (c == TAB)
  110.                   for (space = (colcnt % 8); space++ < 8; colcnt++)
  111.                      *bufptr++ = SPACE;
  112.                else {
  113.                   *bufptr++ = c;
  114.                   colcnt++;
  115.                }
  116.             }
  117.             *bufptr++ = c;
  118.             if ((c = strcmp(&header[0], &buf[7])) == NULL)
  119.                ;
  120.             else
  121.                putline(&buf[0], tmp);
  122.          }
  123.       }
  124.  
  125.       while ((d = feof(org)) != FEOF && c != EOF) {
  126.          colcnt = 0;
  127.          while ((c = fgetc(org)) != CR && c != LF && c != EOF) {
  128.             if (c == TAB)
  129.                for (space = (colcnt % 8); space++ < 8; colcnt++)
  130.                   fputc(SPACE, tmp);
  131.             else {
  132.                fputc(c,tmp);
  133.                colcnt++;
  134.             }
  135.          }
  136.       (c == EOF) ? fputc('\x1a',tmp) : fputc(c,tmp);
  137.       if ((++lncnt % 25) == 0)
  138.          printf(".");
  139.       }
  140.  
  141.       fclose(org);
  142.       fclose(tmp);
  143.  
  144.       return(0);
  145. }
  146.  
  147. rename(file1, file2)
  148. char  *file1, *file2;
  149. {
  150.       int   ret, *inxptr;
  151.       union REGS  inregs, outregs;
  152.       char  *incptr;
  153.  
  154.       unlink(file2);
  155.  
  156.       inxptr = &inregs.x.dx;
  157.       *inxptr = file1;
  158.       inxptr = &inregs.x.di;
  159.       *inxptr = file2;
  160.       incptr = &inregs.h.ah;
  161.       *incptr = '\x56';
  162.  
  163.       ret = intdos(&inregs, &outregs);
  164.  
  165.       if (ret == 3 || ret == 5 || ret == 17)
  166.          return('\xFF');
  167.       else
  168.          return(0);
  169. }
  170.  
  171. chk_flags(args)
  172. char  *args;
  173. {
  174.       int   flags = 0;
  175.       char  *altarg, c;
  176.  
  177.       altarg = ++args;
  178.       while (*altarg) {
  179.          c = toupper(*altarg);
  180.          switch (c) {
  181.             case  'S':
  182.                flags = flags | STRIP_HEADER;
  183.                break;
  184.          }
  185.          altarg++;
  186.       }
  187.  
  188.       return (flags);
  189. }
  190.  
  191. strcmp(string1, string2)
  192. char  *string1, *string2;
  193. {
  194.       while (*string1 == *string2) {
  195.          ++string1;
  196.          if (!*string1)
  197.             return (0);
  198.          ++string2;
  199.       }
  200.  
  201.       if (*string1 < *string2)
  202.          return (-1);
  203.       else
  204.          return (1);
  205.  }
  206.  
  207. putline(buffer, file)
  208. char  *buffer;
  209. FILE  *file;
  210. {
  211.       while (*buffer != NULL) {
  212.          fputc(*buffer, file);
  213.          buffer++;
  214.       }
  215. }
  216.